Probabilistic signature scheme

ABSTRACT

An RSA-based signing scheme that combines essentially optimal efficiency with attractive security properties. One preferred signing routine requires one RSA decryption plus some hashing, verifications requires one RSA encryption plus some hashing, and the size of the signature preferably is the size of the modulus. Given an ideal underlying hash function, the scheme is not only provably secure, but has security tightly related to the security of RSA. An alternative embodiment maintains all of the above features and, in addition, provides message recovery. The techniques can be extended to provide schemes for Rabin-based signatures or signatures using other trapdoor functions.

[0001] This application is based on Provisional Application Serial No. 60/037,530, filed Feb. 10, 1997.

BACKGROUND OF THE INVENTION

[0002] 1. Technical Field

[0003] The present invention relates generally to digital signature schemes and, more particularly, to an RSA-based signing scheme that combines excellent efficiency with attractive security properties.

[0004] 2. Brief Description of the Related Art

[0005] In the RSA public key system, a party has public key (N,e) and secret key (N,d), where N is a k-bit modulus, the product of two (k/2)-bit primes, and e, d ∈Z_(φ(N))* satisfy ed=1 mod Φ(N). The RSA function f: Z_(N)*→Z_(N)* is defined by f(x)=x^(e) mod N and its inverse f⁻¹: Z_(N)*→Z_(N)* is defined by f⁻¹(y)=y^(d) mod N (X, y ∈Z_(N)*, where Z_(N)* denotes the set of numbers between 1 and N−1 which are relatively prime to N). The function f can be used for encryption and f⁻¹ for decryption. The generally-made assumption is that f is trapdoor one-way; roughly, if one does not know d (or the prime factors of N), then it is hard to compute x=f⁻¹(y) for a y drawn randomly from Z_(N)*.

[0006] A widely employed paradigm to sign a document M is to first compute some “hash” y=Hash(M) and then set the signature to x=f⁻¹(y) y^(d) mod N. To verify that x is a signature of M, one computes f(x)=x^(e) mod N and checks that this equals Hash(M) This technique is the basis for several existing standards. A necessary requirement on Hash in such a scheme is that it be collision-intractable and produce a k-bit output that encodes a point in Z_(N)*. Accordingly, Hash is most often implemented via a cryptographic hash function like h=MD5 (which yields a 128 bit output and is assumed to be collision-intractable) and some padding. A concrete example of such a scheme is described in PKCS #1: RSA Encryption Standard (Version 1.4), June 1991, and PKCS #7, Cryptographic Message Syntax Standard (Version 1.4), June 1991, RSA Data Security, Inc., where the hash is:

Hash_(PCKS)(M)=0×0001FFFF . . . FFFF00|h(M).

[0007] In the above expression, the “0×” indicates that the following number is written in hexadecimal notation, and “|” denotes concatenation. Such a signature scheme may be called a “hash-then-decrypt” scheme.

[0008] The security of a hash-then-decrypt signature depends on how Hash is implemented. But the security of a scheme like Sign_(PKCS)(M)=f⁻¹ (Hash_(PKCS)(M)) cannot be justified given only that RSA is trapdoor one-way, even under the assumption that hash function h is ideal. This is because the set of points {Hash_(PKCS)(M): M∈{0,1}*} has size at most 2¹²⁸ and hence is a very sparse, and a very structured, subset of Z_(N)*. This lack of demonstrable security is disadvantageous. In particular, although there is no known attack on this scheme, it is preferable to have a signature scheme with some proof of security. The same issue arises for other known standards, including ISO/IEC 9796. There, the hash function involves no cryptographic hashing, and the message M is easily recovered from Hash(M).

[0009] Thus, the security of the current PKCS standards, as well as that of the ISO standard, cannot be justified based on the assumption that RSA is trapdoor one-way. Other standards, such as described in Privacy Enhancement for Internet Electronic Mail: Part III Algorithms, Modes, and Identifiers, by Balenson, IETF RFC 1423, February, 1993, are similar to the RSA standard, and the same reasoning applies.

[0010] Signature schemes whose security can be provably based on the RSA assumption include the schemes described in the following representative publications: Goldwasser, Micali and Rivest, A digital signature scheme secure against adaptive chosen-message attacks, SIAM Journal of Computing, 17(2):281-308, April 1988; Bellare and Micali, How to sign given any trapdoor permutation, JACM Vol. 9, No. 1, 214-233, January, 1992; Naor and Yung, Universal one-way hash functions and their cryptographic applications, Proceedings of the 21st Annual Symposium on Theory of Computing, ACM, 1989; Rompel, One-way Functions are Necessary and Sufficient for Secure Signatures, Proceedings of the 22nd Annual Symposium on Theory of Computing, ACM, 1990; and Dwork and Noar, An efficient existentially unforgeable signature scheme and its applications, Advances in Cryptology—Crypto 94 Proceedings, Lecture Notes in Computer Science Vol. 839, Y. Desmedt. ed., Springer-Verlag, 1994. The major advantage of these works is that they can be proven to be sound, under some formalized mathematical assumption. On the other hand, these are not practical schemes; their cost (in computation time and storage) is so high that they are not considered for real world security applications.

[0011] There are additional signature schemes that have been proven secure under the assumption that a hash function which they use behaves as though it were a random function. Such schemes can be based on the hardness of factoring, or on other assumptions. Some of these schemes have been derived from identification schemes, as was first described by Fiat and Shamir, How to prove yourself: practical solutions to identification and signature problems, Advances in Cryptology—Crypto 86 Proceedings, Lecture Notes in Computer Science, Vol. 263, A. Odlyzko ed., Springer-Verlag, 1986. The efficiency of those schemes varies. The computational requirements are often lower than a hash-then-decrypt RSA signature, although key sizes are typically larger.

[0012] The paradigm of protocol design using hash functions that are regarded (in proofs) as random functions is thus well-developed, as described in Bellare and Rogaway, Random oracles are practical: a paradigm for designing efficient protocols, Proceedings of the First Annual Conference on Computer and Communications Security, ACM, 1993; and Bellare and Rogaway, Optimal Asymmetric Encryption, Advances in Cryptology—Eurocrypt 94 Proceedings, Lecture Notes in Computer Science Vol. 950, A. De Santis ed., Springer-Verlag, 1994.

[0013] When a signature scheme is proven secure, the security proof demonstrates how to transform an attack on the signature scheme into an attack on the underlying mathematical primitive. For example, in a scheme based on factoring numbers, the proof would show how to turn a forging algorithm against the signature scheme into a factoring algorithm. The efficiency of this “reduction” quantifies the demonstrated security. A signature scheme is said to have “tight” demonstrated security if it has been proven secure by a highly efficient reduction. Tight demonstrated security is desirable because for such a scheme the security parameter (e.g., length of RSA modulus) which is deemed adequate for the mathematical primitive is necessarily adequate for the signature scheme, too.

[0014] None of the prior art has taught a signature scheme with tight demonstrated security based on a simple construction. There remains a need in the art to provide new signature schemes that fall in the hash-then-decrypt paradigm, so that they are easy to implement, yet are simple, efficient, and practical, and, above all, have attractive security properties like tight demonstrated security. The present invention addresses this need.

BRIEF SUMMARY OF THE INVENTION

[0015] An object of the present invention is to provide new signature schemes that are as simple and efficient as standardized ones. Assuming the underlying hash function is ideal, the inventive methods are not only provably secure, but provably secure in a strong sense. In one embodiment involving RSA, signing takes one RSA decryption plus some hashing, verification takes one RSA encryption plus some hashing, and the size of the signature is the size of the modulus. The security of the inventive scheme in this embodiment is tightly related to the security of the RSA function.

[0016] The inventive teachings are also extended to provide schemes for Rabin signatures with analogous properties; in particular, their security can be tightly related to the hardness of factoring.

[0017] It is known to hash a message M onto the full domain Z_(N)* of the RSA function before decrypting. The signature of M is f¹ (h(M)), where h is constructed to spread its argument uniformly into Z_(N)*. According to the present invention, such a known technique is strengthened by making the hashing probabilistic. In order to sign message M, the signer first picks a random seed r of length k₀, where k₀<k is a parameter of the scheme (recall k=|N|). Then, using some hashing, in a specific way, the signer produces from M and r an image point y=Hash_(PSS)(r,M) ∈Z_(N)* . As usual, the signature is then x=f⁻¹(y)=y^(d) mod N. Verification is more difficult, because one cannot simple re-compute a probabilistic hash of M and expect to get the same value. Still, verification takes only one RSA encryption and some hashing, as will be seen below.

[0018] The inventive scheme is as efficient as known signing schemes based on RSA. But, it can be shown that the security of the inventive scheme is tightly related to that of RSA. Thus, for example, if the RSA inversion probability was originally 2⁻⁶¹ (using a certain amount of computational resources), then the probability of forgery for the signature scheme is almost equally low (assuming the same computational resources).

[0019] According to the invention, signing with “message recovery” is also provided. This technique reduces the bandwidth required for sending a signed message. In this technique, rather than transmit the message M and its signature x, a single enhanced signature τ, of length less than |M|+|x|, is transmitted. The verifier is able to recover M from τ and simultaneously check the authenticity. With security parameter k=1024, the inventive scheme enables one to authenticate a message of up to, say, n=767 bits by transmitting only a total of k bits. The signing with message recovery scheme accomplishes this by appropriately folding the message into the signature in such a way that the verifier can recover it. The computational efficiency and security are the same as for the first-described scheme.

[0020] In a further embodiment, the inventive technique is applied to the known Rabin function, with security tightly related to the hardness of factoring.

[0021] The foregoing has outlined some of the more pertinent objects and features of the present invention. These objects should be construed to be merely illustrative of some of the more prominent features and applications of the invention. Many other beneficial results can be attained by applying the disclosed invention in a different manner or modifying the invention as will be described. Accordingly, other objects and a fuller understanding of the invention may be had by referring to the following Detailed Description of the Preferred Embodiment.

BRIEF DESCRIPTION OF THE DRAWINGS

[0022] The novel features believed characteristic of the invention are set forth in the appended claims The invention itself however, as well as a preferred mode of use, further objects and advantages thereof, are best understood by reference to the following Detailed Description of an illustrative embodiment when read in conjunction with the accompanying Drawings, wherein:

[0023]FIG. 1 is a high level description of a preferred method of signing a message according to the present invention;

[0024]FIG. 2 is a diagram illustrating a preferred technique for generating an image point in a first signature scheme PSS of the present invention;

[0025]FIG. 3 is a diagram illustrating a preferred technique for generating an image point in a second signature scheme PSS-R of the present invention; and

[0026]FIG. 4 is a diagram illustrating a preferred technique for implementing the present invention with a Rabin signature scheme.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[0027] By way of brief background, it is known that RSA is a family of trapdoor permutations. It is specified by the RSA generator, RSA, which, on input k, picks a pair of random distinct (k/2)-bit primes and multiplies them to produce a modulus N. It also picks, at random, an encryption exponent e ∈Z_(Φ(N))* and computes the corresponding decryption exponent d so that ed=1 modΦ(N). The RSA generator returns N, e, d, these values specifying f: Z_(N)*→Z_(N)* and f⁻¹: Z_(N)*→Z_(N)*, which are defined by f(x)=x^(e) mod N and f⁻¹(y)=y^(d) mod N. Both functions are permutations, and, as the notation indicates, inverses of each other. The function f is the RSA encryption primitive and the function f⁻¹ is the RSA decryption primitive.

[0028] The trapdoor permutation generator RSA-3 is identical to RSA except that the encryption exponent e is fixed to be 3. More generally, RSA-e provides an encryption exponent of the specified constant. Other variants of RSA use a somewhat different distribution on the modulus N. The present invention, although stated for RSA, also hold for these other variants.

[0029] An inverting algorithm for RSA, I, gets input N, e, y and tries to find f⁻¹(y). Its success probability is the probability that it outputs f⁻¹(y) when N, e, d are obtained by running RSA(k) and y is set to f(x) for an x chosen at random from Z_(N)* . The standard asymptotic definition of security requires that the success probability of any PPT (probabilistic, polynomial time) algorithm be a negligible function of k. The present invention goes further and, in particular, is interested in exactly how much time an inverting algorithm uses and what success probability it achieves in this time. Formally, an inverting algorithm is said to be a t-inverter, where t: IN→IN, if its running time plus the size of its description is bounded by t(k), in some fixed standard model of computation. The function I (t,∈)-breaks RSA, where ∈: IN→[0,1], if I is a t-inverter and for each k the success probability of I is at least ∈ (k). The generator RSA is (t, ∈)-secure if there is no inverter which (t, ∈)-breaks RSA.

[0030] By way of further background, a digital signature scheme Π=(Gen, Sign, Verify) is specified by a key generation algorithm, Gen, a signing algorithm, Sign, and a verifying algorithm, Verify. The first two are probabilistic, and all three should run in expected polynomial time. Given k, the key generation algorithm outputs a pair of matching public and secret keys, (pk, sk). The signing algorithm takes the message M to be signed and the secret key sk, and it returns a signature x=Sign_(sk)(M). The algorithm may entail probabilistic choices. The verifying algorithm takes a message M, a candidate signature x′, and the public key pk, and it returns a bit Verify_(pk)(M,x′) with “1” signifying “accept” and “0” signifying “reject.” If x was produced via x←Sign_(sk)(M), then Verify_(pk)(M,x)=1.

[0031] One or more strong hash functions will usually be available to the algorithms Sign and Verify, with their domain and range depending on the scheme. According to the present invention, these functions are modeled as ideal, meaning that if hash function h is invoked on some input, the output is a uniformly distributed point of the range. If invoked twice on the same input, the same result is returned both times. In security proofs, h is modeled as a public random oracle (a “hash oracle”) to be accessed via oracle queries, i.e., an algorithm can write a string z and get back h(z) in time |z|.

[0032] Definitions for the security of signatures in the asymptotic setting are known in the art. The following describes an “exact version” of these definitions. In particular, a forger takes as input a public key pk, where (pk, sk)←Gen(k), and tries to forge signatures with respect to pk. The forger is allowed a chosen message attack in which it can request, and obtain, signatures of messages of its choice. This is modeled by allowing the forger access to the signing algorithm. The forger is deemed successful is it outputs a valid forgery, namely, a message/signature pair (M,x) such that Verify_(pk)(M,x)=1 but M was not a message of which a signature was earlier requested. The forger is said to be a (t, q_(sig), q_(hash))-forger if its running time plus description size is bounded by t(k); it makes at most q_(sig)(k) queries of its signing oracle; and it makes a total of at most q_(hash)(k) queries of its various hash oracles. Such a forger F is said to (t, q_(sig), q_(hash), ∈)-break the signature scheme if, for every k, the probability that F outputs a valid forgery is at least ∈(k). The signature scheme (Gen, Sign, Verify) is (t, q_(sig), g_(hash), ∈)-secure if there is no forger who (t, q_(sig), q_(hash), ∈)-breaks the scheme.

[0033] Referring now to FIG. 1, there is illustrated a high level description of a preferred method of signing a message according to the present invention. If M is the message desired to be signed, then the scheme begins by selecting a random, pseudorandom or otherwise time-varying seed value r. Such a value is sometimes referred to as a “nonce.” A hash function then takes two arguments: the message M and the nonce r. The hash function then produces a keyed hash w=h(r,M). As also seen in the figure, the message is split into two pieces, a first portion M₁ and a second portion M₂, wherein the message M is easily recoverable from knowledge of the first and second portions. It is possible that the first portion or the second portion may take on a null value (or is “void”), such that the remaining portion is then the entire message.

[0034] Then, the signing routine encodes into an image point y (1) the hash value h(r,M), (2) seed value r, and (3) the second portion M₂ of the message M. These values are encoded in such a way so that r, M₂ and h(r,M) each are recoverable given an image point y. Then, the image point y is subjected to the decryption primitive f⁻to generate the signature x of the message M. The remaining portion M₁ of the message (namely, that portion that was not encoded into the image point) is then concatenated or otherwise combined with the signature to form the enhanced signature x.

[0035] Thus, according to the invention, the message M to be signed is decomposed or otherwise split into first and second portions. One of the portions, in effect, is “folded” into the trapdoor permutation, while the other portion (i.e., the portion that does not fit) gets transmitted with the signature x to facilitate the authentication. Thus, the signature scheme is a combined “signature with appendix” and “signature permitting message recovery” scheme within the meaning of ISO/IEC 9796 and ISO/IEC 14888-1.

[0036] A keyed hashing function of M is used with a seed value r, wherein the seed value is communicated in some way in the image point. Preferably, a random seed value r is used for each message. The image point is unpredictable due to the seed value.

[0037] Referring now to FIG. 2, a first detailed embodiment of the inventive probabilistic signature scheme is now illustrated and described. The scheme PSS[k₀, k₁] is described by a key generation algorithm GenPSS, a signing algorithm SignPSS and a verifying algorithm VerifyPSS. The latter two algorithms are parameterized by k₀ and k₁, which are numbers between 1 and k satisfying the relationship k₀+k₁≦k−1. Thus, for example, k=1024, and k₀=k₁=128. Such values, of course, are merely representative. The key generation algorithm GenPSS runs RSA(k) to obtain (N,e,d), and outputs (pk, sk), where the public key is pk=(N,e) and the secret key is sk=(N,d).

[0038] As illustrated in FIG. 2, the signing and verifying algorithms preferably make use of two hash functions. The first, h, sometimes referred to as a compressor, maps as h: {0,1}* x {0,1}*→{0,1}^(k1) and the second, g, sometimes referred as the generator, maps as g: {0,1}^(k1)→{0,1}^(k−k1−1). These functions are preferably implemented from conventional cryptographic hash functions, such as MD5 or SHA-1, as will be described below. For purposes of the scheme, g₁ is a function that, on input w ∈{0,1}^(k1), returns the first k₀ bits of g(w), and g₂ is a function that, on input w ∈{0,1}^(k1), returns the remaining k−k₀−k¹⁻¹ bits of g(w). The signature x of a message M (sometimes referred to herein as a data string) is then:

[0039] SignPSS (M)

r←{0,1}^(k0); w←h(r,M); r*←g₁(w)⊕r

y←0|w|r*|g₂(w)

[0040] return y^(d) mod N

[0041] Thus, given the message M and signature x, verification proceeds as follows:

[0042] VerifyPSS

y←x^(e) mod N

[0043] Let y be decomposed as: b|w|br*|γ,

[0044] (where b is the first bit of y, w the next k₁ bits, r* the next k₀ bits, and γ the remaining bits)

r←r*⊕g₁(w)

[0045] if (h (r,M)=w and g₂(w)=γ and b=0), then return 1; otherwise, return 0.

[0046] Above, the step r←{0,1}^(k0) indicates that the signer picks (preferably at random) a seed r of k₀ bits. The signer then hashes this seed with the message M, for example, by concatenating these strings and applying some cryptographic hash function (such as SHA-1). The result is a k₁-bit string w. Then, the generator g is applied to w to yield a k₀-bit string g₁(w) and a k−k₀−k₁−1 bit string g₂(w). The first bit string is then used to “mask” the k₀-bit seed r, resulting in the masked seed r*. Then, w|r* is prepended with a 0 bit and appended with g₂(w) to create the image point y, which is decrypted under the RSA function to yield the signature x. The 0-bit is to substantially guarantee that y is in Z_(N)*. Preferably, a new seed is chosen for each message. In particular, a given message has many possible signatures, depending on the value of r chosen by the signer.

[0047] Given (M,x), the verifier first computes y=x^(e) mod N and recovers r*, w and r. These values are then used to check that y was correctly constructed, and the verifier only accepts the message if all the checks succeed. Thus, signing takes one application of h, one application of g, and one RSA decryption, while verification takes one application of h, one application of g, and one RSA encryption. Thus, the scheme is quite efficient.

[0048] Another embodiment of the invention is illustrated in FIG. 3, and is now described. By way of brief background, in a standard signature scheme, the signer transmits the message M in the clear, attaching to it the signature x. In a scheme that provides “message recovery,” only an “enhanced signature” x is transmitted. The goal is to save on the bandwidth for sending a signed message. In particular, it is desired that the length of this enhanced signature to be smaller than |M|+k. When M is short enough, it is desired that the length of x be k, the signature length. The verifier then recovers the message M from the enhanced signature and checks authenticity at the same time.

[0049] Signing with message recovery is accomplished according to the present invention by “folding” some or all of the message into the signature in such a way that it is “recoverable” by the verifier. When the length n of M is small, the entire message can be folded into the signature, so that only a k-bit quantity is transmitted. In the preferred scheme defined below, if the security parameter is k=1024, k₀=128, and k₁=128, one can fold up to 767 message bits into the signature. This value, of course, is merely representative.

[0050] In a signature scheme permitting message recovery, the definition of the key generation and signing algorithms are as described previously, but the verification algorithm is replaced by a “recovery algorithm” which takes the public key pk and the enhanced signature x and returns Recover_(pk)(x)∈{0,1}*∪{REJECT}. The distinguished point REJECT is used to indicate that the recipient rejected the signature; a return value of M ∈{0,1}* indicates that the verifier accepts the message M as authentic. The formulation of security is the same as that above except for what it means for the forger to be successful. In particular, it should provide an x such that M=Recover_(pk)(x) ∈{0,1}*, where M was not a previous signing query. If x was produced via x←Sign_(sk) (M), then Recover_(pk) (x)=M.

[0051] A simple variant of the PSS scheme achieves message recovery. The scheme PSS-R [k₀, k₁] includes the same key generation algorithm GenPSS as previously described. As with PSS, the signing and verification algorithms depend on hash function h: {0,1}* x {0,1}*→{0,1}^(k1) and g: {0,1}*→{0,1}^(k−k1−1), and the same g₁ and g₂ notation is used as before. For simplicity of explanation, it is assumed that the messages to be signed have length exactly n=k−k₀−k₁−1. Thus, possible choices of parameters are k 1024, with k₀=k₁=128 and n=767. As previously noted, these values are merely representative. In this embodiment, an enhanced signature of only k bits is generated from which the verifier can recover the n-bit message and simultaneously check authenticity. Signature generation and verification proceed as follows:

[0052] SignPSS-R(M)

r←{0,1}^(k0); w←h(r,M); r*←g₁(w)θr

M*←g₂(w)⊕M

y←0|w|r*|M*

[0053] return y^(d) mod N

[0054] RecoverPSS-R (x)

y←x^(e) mod N

[0055] Let y be decomposed into: b|w|r*|M*,

[0056] (where b is the first bit of y, w the next k₁ bits, n* the next k₀ bits, and M the remaining r bits)

r←r*⊕g₁(w)

M←<M*⊕g₂(w)

[0057] if (h(r,M)=w and b=0), then return M; otherwise, return REJECT.

[0058] Thus, SignPSS-R differs with respect to the signature algorithm of the first embodiment (SignPSS) in that the last part of the image y is not g₂(w). Instead, g₂(w) is used to “mask” the message, and the masked message M* is the last part of the image point y. This scheme is then easily adapted to handle messages of arbitrary length. A fully-specified scheme preferably would use about min{k, n+k₀+k₁+16} bits for the enhanced signature of the n-bit message M.

[0059] The present invention extends to Rabin signatures, yielding a signature scheme and a signing with recovery scheme whose security can be tightly related to the hardness of factoring. In the basic Rabin signature scheme described in Digitalized Signatures and Public Key Functions as Intractable as Factorization, MIT/LCS/TR-221, January 1979, the signer chooses a number N=pg that is the product of two large primes, and the signer further chooses a number 0≦b<N (for example, the signer may choose b=0). The signer's public key is (N,b) and the corresponding secret key is (p,q,b). To sign a message M, the signer chooses a random seed r and computes a hash w=h(r,M) The point w is regarded as a value in Z_(N),* the multiplicative group of integers modulo N. The signer then checks if the equation x(x+b)=w has a solution in the multiplicative group of integers modulo N. This can be done using the signer's private key in a manner well-known in the art and described by Rabin. If the above equation has no solution, then the signer chooses a new random seed r and repeats the process described above. If the equation does have a solution the signer chooses one such solution, call it x, and the signature of M is taken to be the ordered pair (x,r).

[0060] An analogous scheme is implemented in the present invention and has equally efficient computation time but shorter signatures (because there is no need to separately transmit the seed r as part of the signature).

[0061] The probabilistic Rabin scheme is defined by PRab[k₀, k₁]=(GenPRab, SignPRab, VerifyPRab), and depends on parameters k₀, k₁, where k₀+k₁≦k. Algorithm GenPRab, on input k, picks a pair of random distinct (k/2)-bit primes p,q and multiplies them to produce the k-bit modulus N. It outputs (pk,sk), where pk=N and sk=(N, p,q).

[0062] The signing and verifying algorithms of PRab preferably use hash functions h,g, where h: {0,1}* x {0,1}*→{0,1}^(k1) and g: {0,1}^(k1)→{0,1}^(k−k1). In particular, let g₁ be the function that on input w ∈{0,1}^(k1) returns the first k₀ bits of g(w) and let g₂ be the function that on input w ∈{0,1}^(k1) returns the remaining k−k₀−k₁ bits of g(w)

[0063] The signing procedure, SignPRab, is similar to the corresponding SignPSS, but this routine returns a random square root of the image y, as opposed to y^(d) mod N. The verification procedure checks if the square of the signature has the correct image. Thus verification is particularly fast. Here, in full, are preferred forms of SignPRab (illustrated in FIG. 4) and

[0064] VerifyPRab:

[0065] SignPRab (M)

[0066] repeat

r←{0,1}^(k0); w←h(r,M); r*←g₁(w)⊕r

y←w|r*|g₂(w)

[0067] until y ∈Z*_(N) and y is a quadratic residue mod N.

[0068] Let {x₁, x₂, x₃, x₄} be the four distinct square roots of y in Z*_(N).

[0069] Choose x←{x₁, x₂, x₃, x₄} at random.

[0070] return x.

[0071] VerifyPRab (M,x)

y←x² mod N

[0072] Break up y as w|r*|Υ. (That is, let w be the first k₁ bits of y, r* the next k₀ bits, and Υ the remaining bits.)

r←r*⊕g₁(w)

[0073] if (h(r,M)=w and g₂(w)=Υ) then return 1; else return 0.

[0074] As with PSS, one can add message recovery to the Rabin scheme in the same way, resulting in a probabilistic Rabin signing-with-recovery scheme, PRab-R. Its security is the same as that of the Rabin-based scheme.

[0075] Thus, in the Rabin schemes, the seed value r is chosen repeatedly until the image string y is in the domain of the decryption primitive and the primitive is the probabilistic function that returns a random square root of the image point in the multiplicative group of integers modulo a product of two primes. Thus, a “Rabin decryption primitive” is a map which takes a square x² in Z_(N)* and returns a random square root of x². The seed itself is encoded into the image point so that it does not have to be transmitted separately from the decrypted image point.

[0076] Note that an RSA-based scheme could take on a similar form, where the seed value is chosen repeatedly until y is in the domain; in such case, the leading “0” bit of y (as described above) would not be necessary. Moreover, variants of Rabin encryption, such as those described in ISO/IEC 9796, could be applied (in the Rabin scheme above) to reduce the number of iterations.

[0077] The previously described PSS, PSS-R, Prab, and PRab-R schemes require a concrete hash function h with output length some given number k₁. Typically, H may be constructed from some cryptographic hash function H such as H=MD5 or H=SHA-1. A simple technique is to define h(x) as the appropriate-length prefix of:

h(const.<0>.x|h(const.<1>.x|h(const.<2>.x| . . .

[0078] The constant const should be unique to h. To make another hash function, g, one simply selects a different constant. Many similar such constructions are possible of course.

[0079] The present invention provides numerous advantages. It can be shown that the security of the PSS (or PSS-R) is based on the security of RSA, but with a relationship between the two that is much “tighter” than in the prior art. In particular, it has been shown that if the RSA generator is (t′, ∈′) secure, then for any q_(sig), q_(hash), the signature scheme PSS[k₀, k₁] (or PSS-R) is (t, q_(sig), q_(hash), ∈)-secure, where:

t(k)=t′(k)−[q _(sig)(k)+q _(hash)(k)+1]·k ₀·Θ(k ³),

[0080] and

∈(k)=∈(k)+[3(q _(sig)(k)+q_(hash)(k))²]·(2^(−k0)+2^(−k1)).

[0081] With respect to the Rabin probabilistic scheme, it has been shown that if factoring is (t′,e′)-hard, then, for any q_(sig), q_(hash), the signature scheme PRab[k₀, k₁] is (t, q_(sig), q_(hash), ∈)-secure, where:

t(k)=t′(k)−[q _(sig)(k)+q _(hash)(k)+1]·k ₀·Θ(k ²),

[0082] and

∈(k)=2∈′(k)+[6(q _(sig)(k)+q_(hash)(k))²]⊕(2^(−k0)+2^(−k1)).

[0083] One of the preferred implementation of the probabilistic signature scheme of the present invention is a computer program. One implementation is in conjunction with a development toolkit. Thus, each of the algorithms of the invention are preferably implemented as a set of instructions (program code or instruction means) in a code module resident in the random access memory (RAM) of a computer. The set of instructions (or some portion thereof) may be stored in another computer memory or downloaded via the Internet or other computer network.

[0084] The computer program comprising the probabilistic signature scheme is executed in a computer. The computer used in the present invention is any personal computer or workstation client or server platform that is Intel-, PowerPC®- or RISC®-based, and that includes an operating system such as IBM® OS/2®, Microsoft Windows 95, Microsoft Windows NT 4.0, Unix, AIX®, OS/400 or the like.

[0085] Although not required, the various processing routines that comprise the present invention may reside on the same host machine or on different machines interconnected over a network (e.g., the Internet, an intranet, a wide area network (WAN) or local area network (LAN)). Thus, for example, the signature of the message may be performed on one machine, with the associated verification then performed on another machine. Thus, a computer running the present invention has appropriate networking hardware to establish a connection to another computer in a conventional manner.

[0086] In addition, although the various methods described are conveniently implemented in a general purpose computer selectively activated or reconfigured by software, one of ordinary skill in the art would also recognize that such methods may be carried out in hardware, in firmware, or in more specialized apparatus constructed to perform the required method steps.

[0087] The particular message “content” is not a limitation of the present invention. Thus, the message may be generalized as any “data string” irrespective of the particular application for which the digital signature scheme is to be used.

[0088] Having thus described our invention, what we claim as new and desire to secure by Letters Patent is set forth in the following claims. 

1. A method of signing a data string, comprising the steps of: (a) hashing the data string and a seed value to generate a hash value; (b) encoding into an image point the hash value, the seed value, and a given portion of the data string; and (c) applying a given decryption primitive to the image point to obtain a digital signature of the data string.
 2. The method of digital signing as described in claim 1 wherein the encoding step includes the steps of: applying a generator function to the hash value to generate a masking value; and using the masking value to mask the seed value and, optionally, the given portion of the data string.
 3. The method of digital signing as described in claim 1 further including the step of concatenating the digital signature with a remaining portion of the data string to facilitate subsequent authentication.
 4. The method of digital signing as described in claim 3 wherein the data string is recoverable from the given portion and the remaining portion.
 5. The method of digital signing as described in claim 1 wherein the given portion of the data string is the data string.
 6. The method of digital signing as described in claim 1 wherein the given portion of the data string is a null value.
 7. The method of digital signing as described in claim 1 wherein the hash of the data string and the seed value in step (a) is computed by hashing a concatenation of the seed value and the data string.
 8. The method of digital signing as described in claim 1 wherein the hash value, the seed value and the given portion of the data string are each recoverable given the image point.
 9. The method as described in claim 1 wherein the given decryption primitive is the RSA decryption primitive.
 10. The method as described in claim 1 wherein the seed value is selected from a group of seed values consisting essentially of a random value, a pseudorandom value, and a time-varying value.
 11. A computer-implemented method of signing and authenticating a data string M having a first portion M₁ and a second portion M₂, wherein the data string is recoverable from M₁ and M₂, comprising the steps of: (a) hashing the data string and a random seed r to generate a hash value h(r,M); (b) encoding into an image point y the hash value h(r,M), the random seed r, and the second portion M₂ of the data string; (c) applying a decryption primitive to the image point y to obtain a digital signature x of the data string; and (d) associating the digital signature x with the first portion M₁ of the data string.
 12. The computer-implemented method of signing as described in claim 11 wherein the step (b) includes the steps of: applying a generator function to the hash value to generate a masking value; and using the masking value to mask the seed value and, optionally, the second portion M₂ of the data string.
 13. The computer-implemented method as described in claim 11 wherein the digital signature is authenticated by: (e) applying an encryption primitive to the digital signature x to generate a candidate image point; (f) decoding the candidate image point to generate candidate values corresponding to the hash value h(r,M), the random seed r, and the second portion M₂ of the data string; (g) forming a candidate data string by combining the candidate value for the second part M₂ of the data string with the first portion M₁; (h) verifying at least that the candidate value for the hash value h(r,M) equals the hash of (i) the candidate value for the random seed and (ii) the candidate data string; and (i) accepting the candidate data string as the data string M if the verification in step (h) is positive.
 14. The computer-implemented method as described in claim 11 wherein the data string is signed in a first computer and the digital signature is authenticated in a second computer.
 15. The computer-implemented method as described in claim 11 wherein the decryption primitive is the RSA decryption primitive.
 16. The computer-implemented method as described in claim 13 wherein the encryption primitive is the RSA encryption primitive.
 17. A method of authenticating a digital signature x of a data string M, wherein the digital signature x has been generated by applying a given decryption primitive to an image point y, the image point y comprising a function of a seed value r, a hash value h(r,M), and a given portion of the data string, the method comprising the steps of: (a) applying a given encryption primitive to the digital signature to generate a candidate image point; (b) decoding the candidate image point to generate candidate values corresponding to the seed value r, the hash value h(r,M), and the given portion of the data string; (c) forming a candidate data string by combining the candidate value for the given portion of the data string with other information; (d) verifying at least that the candidate value for the hash value h(r,M) equals the hash of (i) the candidate value for the seed value and (ii) the candidate data string; and (e) accepting the candidate data string as the data string M if the verification in step (d) is positive.
 18. A computer-implemented cryptographic system, comprising: means for signing a data string M, the signing means comprising: means for hashing a function of the data string and a seed value to generate a hash value; means for encoding into an image point the hash value, the seed value, and a given portion of the data string; and means, using a given primitive, for decrypting the image point to obtain a digital signature of the data string; and means for authenticating the digital signature, the authenticating means comprising: means, using a given primitive, for encrypting the digital signature to generate a candidate image point; means for decoding the candidate image point to generate candidate values corresponding to the seed value, the hash value, and the given portion of the data string; means for generating a candidate data string from at least the candidate value of the given portion of the data string; means for verifying at least that the candidate value for the hash value corresponds to the hash of the candidate seed and the candidate data string; and means responsive to the verifying means for accepting the candidate data string as the data string.
 19. A computer program product in a computer-readable medium for signing a data string M, comprising: means for hashing the data string and a random seed value to generate a keyed hash value; means for encoding into an image point the keyed hash value, the random seed value and a given portion of the data string; and means, using a given primitive, for decrypting the image point to obtain a digital signature of the data string.
 20. The computer program product as described in claim 19 wherein the given primitive is the RSA decryption primitive.
 21. The computer program product as described in claim 19 wherein the given portion of the data string is the data string.
 22. The computer program product as described in claim 19 wherein the means for encoding includes means for masking the random seed value and, optionally, the given portion of the data string, using a given function.
 23. The computer program product as described in claim 22 wherein the given function is an output of a generator applied to the keyed hash value.
 24. A computer-implemented method of signing a data string M having a first portion M₁ and a second portion M₂, wherein the data string is recoverable from M₁ and M₂, comprising the steps of: (a) selecting a random seed r; (b) hashing the data string and the random seed r to generate a hash value h(r,M); (c) encoding into an image point y the hash value h(r,M), the random seed r, and the second portion M₂ of the data string; and (d) applying a decryption primitive to the image point y to obtain a digital signature x of the data string; wherein the random seed r is selected so that the image string y is in the domain of the decryption primitive.
 25. The method as described in claim 24 further including the step of: (d) concatenating the digital signature x with the first portion M₁ of the data string.
 26. The method as described in claim 24 wherein, given the hash value, a first generator g₁ and a second generator g₂, the encoding step (c) concatenates into the image point (i) the hash value, (ii) an XOR of the random seed and an output of the first generator as applied to the hash value, and (iii) an output of the second generator as applied to the hash value.
 27. The method as described in claim 24 wherein, given the hash value, a first generator g₁ and a second generator g₂, the encoding step (c) concatenates into the image point (i) the hash value, (ii) an XOR of the random seed and an output of the first generator as applied to the hash value, and (iii) an XOR of the second portion M₂ of the data string and an output of the second generator as applied to the hash value.
 28. The method as described in claim 24 wherein the decryption primitive is a Rabin decryption primitive. 